/*******************************************************************************
 * Copyright 2011, 2012 Chris Banes.
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
package com.handmark.pulltorefresh.library;

import android.annotation.TargetApi;
import android.content.Context;
import android.graphics.Canvas;
import android.os.Build.VERSION;
import android.os.Build.VERSION_CODES;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.ListAdapter;
import android.widget.ListView;

import com.handmark.pulltorefresh.library.internal.EmptyViewMethodAccessor;
import com.handmark.pulltorefresh.library.internal.LoadingLayout;

public class PullToRefreshListView extends PullToRefreshAdapterViewBase<ListView> {

    private LoadingLayout mHeaderLoadingView;
    private LoadingLayout mFooterLoadingView;

    private FrameLayout mLvFooterLoadingFrame;

    private boolean mListViewExtrasEnabled;

    public PullToRefreshListView(Context context) {
        super(context);
    }

    public PullToRefreshListView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public PullToRefreshListView(Context context, Mode mode) {
        super(context, mode);
    }

    public PullToRefreshListView(Context context, Mode mode, AnimationStyle style) {
        super(context, mode, style);
    }

    @Override
    public final Orientation getPullToRefreshScrollDirection() {
        return Orientation.VERTICAL;
    }

//	@Override
//	protected void onRefreshing(final boolean doScroll) {
//		/**
//		 * If we're not showing the Refreshing view, or the list is empty, the
//		 * the header/footer views won't show so we use the normal method.
//		 */
//		ListAdapter adapter = mRefreshableView.getAdapter();
//		if (!mListViewExtrasEnabled || !getShowViewWhileRefreshing() || null == adapter || adapter.isEmpty()) {
//			super.onRefreshing(doScroll);
//			return;
//		}
//
//		super.onRefreshing(false);
//
//		final LoadingLayout origLoadingView, listViewLoadingView, oppositeListViewLoadingView;
//		final int selection, scrollToY;
//
//		switch (getCurrentMode()) {
//			case MANUAL_REFRESH_ONLY:
//			case PULL_FROM_END:
//				origLoadingView = getFooterLayout();
//				listViewLoadingView = mFooterLoadingView;
//				oppositeListViewLoadingView = mHeaderLoadingView;
//				selection = mRefreshableView.getCount() - 1;
//				scrollToY = getScrollY() - getFooterSize();
//				break;
//			case PULL_FROM_START:
//			default:
//				origLoadingView = getHeaderLayout();
//				listViewLoadingView = mHeaderLoadingView;
//				oppositeListViewLoadingView = mFooterLoadingView;
//				selection = 0;
//				scrollToY = getScrollY() + getHeaderSize();
//				break;
//		}
//
//		// Hide our original Loading View
//		origLoadingView.reset();
//		origLoadingView.hideAllViews();
//
//		// Make sure the opposite end is hidden too
//		oppositeListViewLoadingView.setVisibility(View.GONE);
//
//		// Show the ListView Loading View and set it to refresh.
//		listViewLoadingView.setVisibility(View.VISIBLE);
//		listViewLoadingView.refreshing();
//
//		if (doScroll) {
//			// We need to disable the automatic visibility changes for now
//			disableLoadingLayoutVisibilityChanges();
//
//			// We scroll slightly so that the ListView's header/footer is at the
//			// same Y position as our normal header/footer
//			setHeaderScroll(scrollToY);
//
//			// Make sure the ListView is scrolled to show the loading
//			// header/footer
//			mRefreshableView.setSelection(selection);
//
//			// Smooth scroll as normal
//			smoothScrollTo(0);
//		}
//	}
//
//	@Override
//	protected void onReset() {
//		/**
//		 * If the extras are not enabled, just call up to super and return.
//		 */
//		if (!mListViewExtrasEnabled) {
//			super.onReset();
//			return;
//		}
//
//		final LoadingLayout originalLoadingLayout, listViewLoadingLayout;
//		final int scrollToHeight, selection;
//		final boolean scrollLvToEdge;
//
//		switch (getCurrentMode()) {
//			case MANUAL_REFRESH_ONLY:
//			case PULL_FROM_END:
//				originalLoadingLayout = getFooterLayout();
//				listViewLoadingLayout = mFooterLoadingView;
//				selection = mRefreshableView.getCount() - 1;
//				scrollToHeight = getFooterSize();
//				scrollLvToEdge = Math.abs(mRefreshableView.getLastVisiblePosition() - selection) <= 1;
//				break;
//			case PULL_FROM_START:
//			default:
//				originalLoadingLayout = getHeaderLayout();
//				listViewLoadingLayout = mHeaderLoadingView;
//				scrollToHeight = -getHeaderSize();
//				selection = 0;
//				scrollLvToEdge = Math.abs(mRefreshableView.getFirstVisiblePosition() - selection) <= 1;
//				break;
//		}
//
//		// If the ListView header loading layout is showing, then we need to
//		// flip so that the original one is showing instead
//		if (listViewLoadingLayout.getVisibility() == View.VISIBLE) {
//
//			// Set our Original View to Visible
//			originalLoadingLayout.showInvisibleViews();
//
//			// Hide the ListView Header/Footer
//			listViewLoadingLayout.setVisibility(View.GONE);
//
//			/**
//			 * Scroll so the View is at the same Y as the ListView
//			 * header/footer, but only scroll if: we've pulled to refresh, it's
//			 * positioned correctly
//			 */
//			if (scrollLvToEdge && getState() != State.MANUAL_REFRESHING) {
//				mRefreshableView.setSelection(selection);
//				setHeaderScroll(scrollToHeight);
//			}
//		}
//
//		// Finally, call up to super
//		super.onReset();
//	}
//
//	@Override
//	protected LoadingLayoutProxy createLoadingLayoutProxy(final boolean includeStart, final boolean includeEnd) {
//		LoadingLayoutProxy proxy = super.createLoadingLayoutProxy(includeStart, includeEnd);
//
//		if (mListViewExtrasEnabled) {
//			final Mode mode = getMode();
//
//			if (includeStart && mode.showHeaderLoadingLayout()) {
//				proxy.addLayout(mHeaderLoadingView);
//			}
//			if (includeEnd && mode.showFooterLoadingLayout()) {
//				proxy.addLayout(mFooterLoadingView);
//			}
//		}
//
//		return proxy;
//	}

    protected ListView createListView(Context context, AttributeSet attrs) {
        final ListView lv;
        if (VERSION.SDK_INT >= VERSION_CODES.GINGERBREAD) {
            lv = new InternalListViewSDK9(context, attrs);
        } else {
            lv = new InternalListView(context, attrs);
        }
        return lv;
    }

    @Override
    protected ListView createRefreshableView(Context context, AttributeSet attrs) {
        ListView lv = createListView(context, attrs);

        // Set it to this so it can be used in ListActivity/ListFragment
        lv.setId(android.R.id.list);
        return lv;
    }

    // @Override
    // protected void handleStyledAttributes(TypedArray a) {
    // super.handleStyledAttributes(a);
    //
    // mListViewExtrasEnabled =
    // a.getBoolean(R.styleable.PullToRefresh_ptrListViewExtrasEnabled, true);
    //
    // if (mListViewExtrasEnabled) {
    // final FrameLayout.LayoutParams lp = new
    // FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT,
    // FrameLayout.LayoutParams.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL);
    //
    // // Create Loading Views ready for use later
    // FrameLayout frame = new FrameLayout(getContext());
    // mHeaderLoadingView = createLoadingLayout(getContext(),
    // Mode.PULL_FROM_START, a);
    // mHeaderLoadingView.setVisibility(View.GONE);
    // frame.addView(mHeaderLoadingView, lp);
    // mRefreshableView.addHeaderView(frame, null, false);
    //
    // mLvFooterLoadingFrame = new FrameLayout(getContext());
    // mFooterLoadingView = createLoadingLayout(getContext(),
    // Mode.PULL_FROM_END, a);
    // mFooterLoadingView.setVisibility(View.GONE);
    // mLvFooterLoadingFrame.addView(mFooterLoadingView, lp);
    //
    // /**
    // * If the value for Scrolling While Refreshing hasn't been
    // * explicitly set via XML, enable Scrolling While Refreshing.
    // */
    // if
    // (!a.hasValue(R.styleable.PullToRefresh_ptrScrollingWhileRefreshingEnabled))
    // {
    // setScrollingWhileRefreshingEnabled(true);
    // }
    // }
    // }

    @TargetApi(9)
    final class InternalListViewSDK9 extends InternalListView {

        public InternalListViewSDK9(Context context, AttributeSet attrs) {
            super(context, attrs);
        }

        @Override
        protected boolean overScrollBy(int deltaX, int deltaY, int scrollX, int scrollY, int scrollRangeX,
                                       int scrollRangeY, int maxOverScrollX, int maxOverScrollY, boolean isTouchEvent) {

            final boolean returnValue = super.overScrollBy(deltaX, deltaY, scrollX, scrollY, scrollRangeX,
                    scrollRangeY, maxOverScrollX, maxOverScrollY, isTouchEvent);

            // Does all of the hard work...
            OverscrollHelper.overScrollBy(PullToRefreshListView.this, deltaX, scrollX, deltaY, scrollY, isTouchEvent);

            return returnValue;
        }
    }

    protected class InternalListView extends ListView implements EmptyViewMethodAccessor {

        private boolean mAddedLvFooter = false;

        public InternalListView(Context context, AttributeSet attrs) {
            super(context, attrs);
        }

        @Override
        protected void dispatchDraw(Canvas canvas) {
            /**
             * This is a bit hacky, but Samsung's ListView has got a bug in it
             * when using Header/Footer Views and the list is empty. This masks
             * the issue so that it doesn't cause an FC. See Issue #66.
             */
            try {
                super.dispatchDraw(canvas);
            } catch (IndexOutOfBoundsException e) {
                e.printStackTrace();
            }
        }

        @Override
        public boolean dispatchTouchEvent(MotionEvent ev) {
            /**
             * This is a bit hacky, but Samsung's ListView has got a bug in it
             * when using Header/Footer Views and the list is empty. This masks
             * the issue so that it doesn't cause an FC. See Issue #66.
             */
            try {
                return super.dispatchTouchEvent(ev);
            } catch (IndexOutOfBoundsException e) {
                e.printStackTrace();
                return false;
            }
        }

        @Override
        public void setAdapter(ListAdapter adapter) {
            // Add the Footer View at the last possible moment
            if (null != mLvFooterLoadingFrame && !mAddedLvFooter) {
                addFooterView(mLvFooterLoadingFrame, null, false);
                mAddedLvFooter = true;
            }

            super.setAdapter(adapter);
        }

        @Override
        public void setEmptyView(View emptyView) {
            PullToRefreshListView.this.setEmptyView(emptyView);
        }

        @Override
        public void setEmptyViewInternal(View emptyView) {
            super.setEmptyView(emptyView);
        }

    }

}
